import json
from typing import Dict, Any, List


class ResultFormatter:
    """解析结果格式化器，保持原始结构只替换值"""
    
    @staticmethod
    def format_parse_result(original_config: Dict[str, Any], parsed_data: Dict[str, Any]) -> Dict[str, Any]:
        """
        格式化解析结果，保持原始配置结构，只替换值
        
        Args:
            original_config: 原始JSON配置
            parsed_data: 解析出的数据
            
        Returns:
            格式化后的结果，保持原始结构但值已更新
        """
        if not original_config or not parsed_data:
            return original_config or {}
            
        # 深拷贝原始配置
        result = json.loads(json.dumps(original_config))
        
        # 获取body数据
        body_data = parsed_data.get('body', {})
        
        # 递归替换值
        ResultFormatter._replace_values_simple(result, body_data)
        
        return result
    
    @staticmethod
    def _replace_values_simple(config: Dict[str, Any], body_data: Dict[str, Any]):
        """
        简化的值替换方法
        
        Args:
            config: 要更新的配置
            body_data: 解析出的body数据
        """
        if isinstance(config, dict):
            for key, value in config.items():
                if isinstance(value, dict):
                    # 检查是否为MAP类型
                    if value.get('type') == 'MAP' and 'entries' in value:
                        ResultFormatter._replace_map_values_simple(value, body_data)
                    elif value.get('type') == 'ARRAY' and 'fields' in value:
                        ResultFormatter._replace_array_values_simple(value, body_data)
                    elif value.get('type') == 'BITFIELD' and 'bits' in value:
                        # 处理BITFIELD类型
                        ResultFormatter._replace_bitfield_values(value, body_data)
                    else:
                        # 普通字典递归处理
                        ResultFormatter._replace_values_simple(value, body_data)
                elif isinstance(value, list):
                    # 处理数组
                    for item in value:
                        if isinstance(item, dict):
                            ResultFormatter._replace_values_simple(item, body_data)
                elif key == 'value':
                    # 直接替换value字段
                    if key in body_data:
                        config[key] = body_data[key]
                    # 尝试按名称匹配
                    elif 'name' in config and config['name'] in body_data:
                        config[key] = body_data[config['name']]
    
    @staticmethod
    def _replace_map_values_simple(map_config: Dict[str, Any], body_data: Dict[str, Any]):
        """简化的MAP值替换"""
        entries = map_config.get('entries', [])
        if not entries:
            return
            
        # 遍历配置中的entries，更新值
        for entry in entries:
            if isinstance(entry, dict):
                key = entry.get('key')
                if key in body_data:
                    entry['value'] = body_data[key]
    
    @staticmethod
    def _replace_array_values_simple(array_config: Dict[str, Any], body_data: Dict[str, Any]):
        """简化的ARRAY值替换"""
        fields = array_config.get('fields', [])
        if not fields:
            return
            
        # 遍历配置中的fields，更新值
        for field in fields:
            if isinstance(field, dict):
                name = field.get('name')
                if name in body_data:
                    field['value'] = body_data[name]
    
    @staticmethod
    def _replace_bitfield_values(bitfield_config: Dict[str, Any], body_data: Dict[str, Any]):
        """BITFIELD值替换"""
        name = bitfield_config.get('name')
        if name not in body_data:
            return
            
        # 获取解析出的BITFIELD数据
        bitfield_data = body_data[name]
        if not isinstance(bitfield_data, dict):
            return
            
        # 获取原始位值
        raw_value = bitfield_data.get('raw_value', 0)
        
        # 遍历配置中的bits，更新值
        bits = bitfield_config.get('bits', [])
        for bit in bits:
            if isinstance(bit, dict):
                bit_index = bit.get('bitIndex', 0)
                bit_length = bit.get('bitLength', 1)
                
                # 从原始值中提取位值
                mask = (1 << bit_length) - 1
                bit_value = (raw_value >> bit_index) & mask
                bit['value'] = bit_value
    
    @staticmethod
    def _replace_values_advanced(config: Dict[str, Any], parsed_data: Dict[str, Any], path: str = ""):
        """
        高级递归替换值，特别处理MAP和ARRAY结构
        
        Args:
            config: 要更新的配置
            parsed_data: 解析出的数据
            path: 当前路径
        """
        if isinstance(config, dict):
            for key, value in config.items():
                current_path = f"{path}.{key}" if path else key
                
                if isinstance(value, dict):
                    # 检查是否为MAP类型
                    if value.get('type') == 'MAP' and 'entries' in value:
                        ResultFormatter._replace_map_values(value, parsed_data, current_path)
                    elif value.get('type') == 'ARRAY' and 'fields' in value:
                        ResultFormatter._replace_array_values_advanced(value, parsed_data, current_path)
                    else:
                        # 普通字典递归处理
                        if key in parsed_data and isinstance(parsed_data[key], dict):
                            ResultFormatter._replace_values_advanced(value, parsed_data[key], current_path)
                        else:
                            ResultFormatter._replace_values_advanced(value, parsed_data, current_path)
                elif isinstance(value, list):
                    # 处理数组
                    if key in parsed_data and isinstance(parsed_data[key], list):
                        ResultFormatter._replace_array_values_advanced(value, parsed_data[key], current_path)
                    else:
                        # 如果不是数组，跳过处理
                        pass
                elif key == 'value':
                    # 尝试多种路径匹配
                    if path in parsed_data:
                        config[key] = parsed_data[path]
                    elif current_path in parsed_data:
                        config[key] = parsed_data[current_path]
                    elif key in parsed_data:
                        config[key] = parsed_data[key]
                    else:
                        # 尝试从body中获取值
                        if 'body' in parsed_data and isinstance(parsed_data['body'], dict):
                            body_data = parsed_data['body']
                            if key in body_data:
                                config[key] = body_data[key]
                            elif current_path in body_data:
                                config[key] = body_data[current_path]
    
    @staticmethod
    def _replace_map_values(map_config: Dict[str, Any], parsed_data: Dict[str, Any], path: str):
        """
        替换MAP结构的值
        
        Args:
            map_config: MAP配置
            parsed_data: 解析数据
            path: 当前路径
        """
        entries = map_config.get('entries', [])
        if not entries:
            return
            
        # 获取解析出的MAP数据
        map_data = parsed_data.get(path, {})
        if not isinstance(map_data, dict):
            # 尝试从根路径获取
            path_parts = path.split('.')
            if len(path_parts) > 1:
                root_key = path_parts[-1]  # 获取最后一个部分
                map_data = parsed_data.get(root_key, {})
        
        if not isinstance(map_data, dict):
            return
            
        # 遍历配置中的entries，更新值
        for entry in entries:
            if isinstance(entry, dict):
                key = entry.get('key')
                if key in map_data:
                    entry['value'] = map_data[key]
    
    @staticmethod
    def _replace_array_values_advanced(config_array: List[Any], parsed_array: List[Any], path: str):
        """
        替换数组中的值（高级版本）
        
        Args:
            config_array: 配置数组
            parsed_array: 解析数组
            path: 当前路径
        """
        if not parsed_array:
            return
            
        for i, item in enumerate(config_array):
            if i < len(parsed_array):
                if isinstance(item, dict) and isinstance(parsed_array[i], dict):
                    ResultFormatter._replace_values_advanced(item, parsed_array[i], f"{path}[{i}]")
                elif isinstance(item, dict):
                    # 如果解析数据不是字典，尝试直接替换value字段
                    if 'value' in item:
                        item['value'] = parsed_array[i]
    
    @staticmethod
    def _replace_values(config: Dict[str, Any], parsed_data: Dict[str, Any], path: str = ""):
        """
        递归替换配置中的值
        
        Args:
            config: 要更新的配置
            parsed_data: 解析出的数据
            path: 当前路径（用于调试）
        """
        if isinstance(config, dict):
            for key, value in config.items():
                current_path = f"{path}.{key}" if path else key
                
                if isinstance(value, dict):
                    # 递归处理嵌套字典
                    if key in parsed_data and isinstance(parsed_data[key], dict):
                        ResultFormatter._replace_values(value, parsed_data[key], current_path)
                    else:
                        ResultFormatter._replace_values(value, parsed_data, current_path)
                elif isinstance(value, list):
                    # 处理数组
                    if key in parsed_data and isinstance(parsed_data[key], list):
                        ResultFormatter._replace_array_values(value, parsed_data[key], current_path)
                    else:
                        ResultFormatter._replace_array_values(value, parsed_data, current_path)
                elif key == 'value' and path in parsed_data:
                    # 替换值字段
                    config[key] = parsed_data[path]
                elif key == 'value' and current_path in parsed_data:
                    # 替换值字段（使用完整路径）
                    config[key] = parsed_data[current_path]
    
    @staticmethod
    def _replace_array_values(config_array: List[Any], parsed_array: List[Any], path: str):
        """
        替换数组中的值
        
        Args:
            config_array: 配置数组
            parsed_array: 解析数组
            path: 当前路径
        """
        if not parsed_array:
            return
            
        for i, item in enumerate(config_array):
            if i < len(parsed_array):
                if isinstance(item, dict) and isinstance(parsed_array[i], dict):
                    ResultFormatter._replace_values(item, parsed_array[i], f"{path}[{i}]")
                elif isinstance(item, dict):
                    # 如果解析数据不是字典，尝试直接替换value字段
                    if 'value' in item:
                        item['value'] = parsed_array[i]
    
    @staticmethod
    def format_simple_result(parsed_data: Dict[str, Any]) -> Dict[str, Any]:
        """
        格式化简单解析结果（当没有原始配置时）
        
        Args:
            parsed_data: 解析出的数据
            
        Returns:
            格式化后的结果
        """
        return parsed_data
    
    @staticmethod
    def merge_config_and_data(config: Dict[str, Any], data: Dict[str, Any]) -> Dict[str, Any]:
        """
        合并配置和数据，保持配置结构但使用数据值
        
        Args:
            config: 原始配置
            data: 解析数据
            
        Returns:
            合并后的结果
        """
        if not config:
            return data
        if not data:
            return config
            
        # 深拷贝配置
        result = json.loads(json.dumps(config))
        
        # 递归合并
        ResultFormatter._merge_recursive(result, data)
        
        return result
    
    @staticmethod
    def _merge_recursive(config: Dict[str, Any], data: Dict[str, Any]):
        """
        递归合并配置和数据
        
        Args:
            config: 配置对象（会被修改）
            data: 数据对象
        """
        if isinstance(config, dict) and isinstance(data, dict):
            for key, value in config.items():
                if key in data:
                    if isinstance(value, dict) and isinstance(data[key], dict):
                        ResultFormatter._merge_recursive(value, data[key])
                    elif key == 'value':
                        # 替换值字段
                        config[key] = data[key]
                    elif isinstance(value, list) and isinstance(data[key], list):
                        # 处理数组
                        ResultFormatter._merge_array(value, data[key])
        
        elif isinstance(config, list) and isinstance(data, list):
            ResultFormatter._merge_array(config, data)
    
    @staticmethod
    def _merge_array(config_array: List[Any], data_array: List[Any]):
        """
        合并数组
        
        Args:
            config_array: 配置数组
            data_array: 数据数组
        """
        for i, item in enumerate(config_array):
            if i < len(data_array):
                if isinstance(item, dict) and isinstance(data_array[i], dict):
                    ResultFormatter._merge_recursive(item, data_array[i])
                elif isinstance(item, dict) and 'value' in item:
                    # 直接替换值
                    item['value'] = data_array[i]
